//
// Copyright (c) 2013-2025 The SRS Authors
//
// SPDX-License-Identifier: MIT
//

#ifndef SRS_APP_DASH_HPP
#define SRS_APP_DASH_HPP

#include <srs_core.hpp>

#include <string>
#include <vector>

#include <srs_app_fragment.hpp>

class ISrsRequest;
class SrsOriginHub;
class SrsMediaPacket;
class SrsFormat;
class SrsFileWriter;
class SrsMpdWriter;
class SrsMp4M2tsInitEncoder;
class SrsMp4M2tsSegmentEncoder;

// The init mp4 for FMP4.
class SrsInitMp4 : public SrsFragment
{
private:
    SrsFileWriter *fw_;
    SrsMp4M2tsInitEncoder *init_;

public:
    SrsInitMp4();
    virtual ~SrsInitMp4();

public:
    // Write the init mp4 file, with the tid(track id).
    virtual srs_error_t write(SrsFormat *format, bool video, int tid);
};

// The FMP4(Fragmented MP4) for DASH streaming.
class SrsFragmentedMp4 : public SrsFragment
{
private:
    SrsFileWriter *fw_;
    SrsMp4M2tsSegmentEncoder *enc_;

public:
    SrsFragmentedMp4();
    virtual ~SrsFragmentedMp4();

public:
    // Initialize the fragment, create the home dir, open the file.
    virtual srs_error_t initialize(ISrsRequest *r, bool video, int64_t time, SrsMpdWriter *mpd, uint32_t tid);
    // Write media message to fragment.
    virtual srs_error_t write(SrsMediaPacket *shared_msg, SrsFormat *format);
    // Reap the fragment, close the fd and rename tmp to official file.
    virtual srs_error_t reap(uint64_t &dts);
};

// The writer to write MPD for DASH.
class SrsMpdWriter
{
private:
    ISrsRequest *req_;

private:
    // The duration of fragment in srs_utime_t.
    srs_utime_t fragment_;
    // The period to update the mpd in srs_utime_t.
    srs_utime_t update_period_;
    // The timeshift buffer depth in srs_utime_t.
    srs_utime_t timeshit_;
    // The base or home dir for dash to write files.
    std::string home_;
    // The MPD path template, from which to build the file path.
    std::string mpd_file_;
    // The number of fragments in MPD file.
    int window_size_;
    // The availabilityStartTime in MPD file.
    srs_utime_t availability_start_time_;
    // The number of current video segment.
    uint64_t video_number_;
    // The number of current audio segment.
    uint64_t audio_number_;

private:
    // The home for fragment, relative to home.
    std::string fragment_home_;

public:
    SrsMpdWriter();
    virtual ~SrsMpdWriter();

public:
    virtual void dispose();

public:
    virtual srs_error_t initialize(ISrsRequest *r);
    virtual srs_error_t on_publish();
    virtual void on_unpublish();
    // Write MPD according to parsed format of stream.
    virtual srs_error_t write(SrsFormat *format, SrsFragmentWindow *afragments, SrsFragmentWindow *vfragments);

public:
    // Get the fragment relative home and filename.
    // The basetime is the absolute time in srs_utime_t, while the sn(sequence number) is basetime/fragment.
    virtual srs_error_t get_fragment(bool video, std::string &home, std::string &filename, int64_t time, int64_t &sn);
    // Set the availabilityStartTime once, map the timestamp in media to utc time.
    virtual void set_availability_start_time(srs_utime_t t);
    virtual srs_utime_t get_availability_start_time();
};

// The controller for DASH, control the MPD and FMP4 generating system.
class SrsDashController
{
private:
    ISrsRequest *req_;
    SrsFormat *format_;
    SrsMpdWriter *mpd_;

private:
    SrsFragmentedMp4 *vcurrent_;
    SrsFragmentWindow *vfragments_;
    SrsFragmentedMp4 *acurrent_;
    SrsFragmentWindow *afragments_;
    // Current audio dts.
    uint64_t audio_dts_;
    // Current video dts.
    uint64_t video_dts_;
    // First dts of the stream, use to calculate the availabilityStartTime in MPD.
    int64_t first_dts_;
    // Had the video reaped, use to align audio/video segment's timestamp.
    bool video_reaped_;

private:
    // The fragment duration in srs_utime_t to reap it.
    srs_utime_t fragment_;

private:
    std::string home_;
    int video_track_id_;
    int audio_track_id_;

public:
    SrsDashController();
    virtual ~SrsDashController();

public:
    virtual void dispose();

public:
    virtual srs_error_t initialize(ISrsRequest *r);
    virtual srs_error_t on_publish();
    virtual void on_unpublish();
    virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
    virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);

private:
    virtual srs_error_t refresh_mpd(SrsFormat *format);
    virtual srs_error_t refresh_init_mp4(SrsMediaPacket *msg, SrsFormat *format);
};

// The MPEG-DASH encoder, transmux RTMP to DASH.
class SrsDash
{
private:
    bool enabled_;
    bool disposable_;
    srs_utime_t last_update_time_;

private:
    ISrsRequest *req_;
    SrsOriginHub *hub_;
    SrsDashController *controller_;

public:
    SrsDash();
    virtual ~SrsDash();

public:
    virtual void dispose();
    virtual srs_error_t cycle();
    srs_utime_t cleanup_delay();

public:
    // Initalize the encoder.
    virtual srs_error_t initialize(SrsOriginHub *h, ISrsRequest *r);
    // When stream start publishing.
    virtual srs_error_t on_publish();
    // When got an shared audio message.
    virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
    // When got an shared video message.
    virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
    // When stream stop publishing.
    virtual void on_unpublish();
};

#endif
